home *** CD-ROM | disk | FTP | other *** search
/ Aminet 4 / Aminet 4 - November 1994.iso / aminet / comm / misc / avmnfaxsrc1_33.lha / serial.c < prev    next >
C/C++ Source or Header  |  1994-06-19  |  7KB  |  227 lines
  1. /* $Header: pd:zvmrcs/serial.c,v 1.1 1993/04/07 18:47:36 rvillari Exp $ */
  2. /*
  3.   Serial Input/Output routines
  4. */
  5.  
  6. #include <clib/exec_protos.h>
  7. #include <clib/alib_protos.h>
  8. #include <exec/memory.h>
  9. #include <stdio.h>
  10. #include "serial_proto.h"
  11. #include "debug_proto.h"
  12.  
  13. struct SerialData* sld = 0;
  14.  
  15. /* PROMISE:  Returns 0 on error, opened serial port on success */
  16. struct SerialData* OpenSerial(char* serialName, int unitNumber, ULONG serialFlags) {
  17.   struct SerialData* serialData = (struct SerialData*) AllocMem(sizeof(struct SerialData), MEMF_CLEAR | MEMF_PUBLIC);
  18.   struct IOExtSer* io;
  19.  
  20.   if (!serialData) {
  21.     mainError("Couldn't allocate memory for SerialData");
  22.     goto bad;
  23.   }
  24.  
  25.   /* create a message port for when the serial device returns stuff to us */
  26.   serialData->SerPort = CreatePort(0, 0);
  27.   if (serialData->SerPort == 0) {
  28.     mainError("Couldn't create a port");
  29.     goto bad;
  30.   }
  31.  
  32.   /* Create the request block for passing info to and from the serial device. */
  33.   serialData->SerReq = (struct IOExtSer *)CreateExtIO(serialData->SerPort,sizeof(struct IOExtSer));
  34.   if (serialData->SerReq == 0) {
  35.     mainError("Couldn't create ExtIO");
  36.     goto bad;
  37.   }
  38.  
  39.   /* creating an alias! */
  40.   io = serialData->SerReq;
  41.   io->io_SerFlags = serialFlags;
  42.  
  43.   /* OPEN the serial.device */
  44.   if (OpenDevice (serialName, unitNumber, (struct IORequest*)serialData->SerReq, 0) != 0) {
  45.     debugString(serialName, "Couldn't open device");
  46.     debugInt(unitNumber, "Unit");
  47.     goto bad;
  48.   }
  49.  
  50. #ifdef DEBUG
  51.   debugInt(serialData->SerReq->io_ReadLen);
  52.   debugInt(serialData->SerReq->io_Baud);
  53.   debugInt(serialData->SerReq->io_CtlChar);
  54.   debugInt(serialData->SerReq->io_WriteLen);
  55.   debugInt(serialData->SerReq->io_StopBits);
  56.   debugInt(serialData->SerReq->io_RBufLen);
  57.   debugInt(serialData->SerReq->io_SerFlags);
  58.   debugInt(serialData->SerReq->io_TermArray.TermArray0);
  59.   debugInt(serialData->SerReq->io_TermArray.TermArray1);
  60. #endif
  61.  
  62.   /* try to change the serial parameters */
  63.   io->io_SerFlags |= serialFlags;
  64.   io->IOSer.io_Command = SDCMD_SETPARAMS;
  65.   if (DoIO ((struct IORequest*)io)) goto bad;
  66.  
  67.   return serialData;
  68.  
  69.  bad:
  70.   if (serialData) {
  71.     if (serialData->SerReq) DeleteExtIO((struct IORequest*)serialData->SerReq);
  72.     if (serialData->SerPort) DeletePort(serialData->SerPort);
  73.     FreeMem(serialData, sizeof(struct SerialData));
  74.   }
  75.   return 0;
  76. }
  77.  
  78. /* PROMISE: close the serial port */
  79. void CloseSerial(struct SerialData* serialData) {
  80.   CloseDevice((struct IORequest*)serialData->SerReq);
  81.   DeleteExtIO((struct IORequest*)serialData->SerReq);
  82.   DeletePort(serialData->SerPort);
  83.   FreeMem(serialData, sizeof(struct SerialData));
  84. }
  85.  
  86. /* PROMISE: change the serial parameters, returns non-zero on error */
  87. int ChangeData(struct SerialData* serialData, ULONG baudRate, UBYTE numBits, UBYTE stopBits, ULONG serialFlags, ULONG readBufferLength) {
  88.   int error;
  89.   struct IOExtSer* io;
  90.   
  91.   io = serialData->SerReq;
  92.   
  93.   io->io_ReadLen       = numBits;
  94.   io->io_BrkTime       = 50000;
  95.   io->io_Baud          = baudRate;
  96.   io->io_CtlChar       = 0x11130000L;
  97.   io->io_WriteLen      = numBits;
  98.   io->io_StopBits      = stopBits;
  99.   io->io_RBufLen       = readBufferLength;
  100.   io->io_SerFlags      = serialFlags;
  101.   io->IOSer.io_Command = SDCMD_SETPARAMS;
  102.   io->io_TermArray.TermArray0 = 0x51040303;
  103.   io->io_TermArray.TermArray1 = 0x03030303;
  104.   
  105.   error = DoIO ((struct IORequest*)io);
  106.  
  107.   return error;
  108. }
  109.  
  110. /* SERIAL I/O functions */
  111.  
  112. /* PROMISE: returns the number of characters in the Amiga's serial
  113. buffer, returns 0 on error (but 0 is also valid) */
  114.  
  115. long SerBuffer(struct SerialData* serialData) {
  116.   serialData->SerReq->IOSer.io_Command = SDCMD_QUERY;
  117.   
  118.   DoIO ((struct IORequest*)serialData->SerReq);
  119.   return ((long)serialData->SerReq->IOSer.io_Actual);
  120. }
  121.  
  122. /* PROMISE: clears the serial port */
  123. void ClearSer(struct SerialData *serialData) {
  124.   serialData->SerReq->IOSer.io_Command = CMD_CLEAR;
  125.   
  126.   DoIO((struct IORequest*)serialData->SerReq);
  127. }
  128.  
  129. /* PROMISE: aborts the current IO request */
  130. void AbortSer(struct SerialData* serialData) {
  131.   AbortIO((struct IORequest*)serialData->SerReq);
  132. }
  133.  
  134. /* PROMISE: checks if an IO request is still active */
  135. long CheckSer(struct SerialData* serialData) {
  136.   return CheckIO((struct IORequest*)serialData->SerReq);
  137. }
  138.  
  139. /* PROMISE: waits for IO request to complete */
  140. long WaitSer(struct SerialData* serialData) {
  141.   int error;
  142.   error = WaitIO((struct IORequest*)serialData->SerReq);
  143.   return error;
  144. }
  145.  
  146. /* PROMISE: waits for IO request to complete */
  147. void WaitWaitSer(struct SerialData* serialData) {
  148.   int error;
  149.   Wait(1L << serialData->SerReq->IOSer.io_Message.mn_ReplyPort->mp_SigBit);
  150.   error = WaitIO((struct IORequest*)serialData->SerReq);
  151. /*  if (error) printf("Error %d\n", error); */
  152. }
  153.  
  154. /* PROMISE: reads from serial port, returns number of characters actually read */
  155. long ReadSer(struct SerialData* serialData, char* data, long length, long* actual)
  156. {
  157.   long error;
  158.   serialData->SerReq->IOSer.io_Data = (APTR)data;
  159.   serialData->SerReq->IOSer.io_Length = (ULONG)length;
  160.   serialData->SerReq->IOSer.io_Command = CMD_READ;
  161.   serialData->SerReq->IOSer.io_Actual = 0;
  162.  
  163. /*
  164.   SendIO((struct IORequest*)serialData->SerReq);
  165.   error = WaitIO((struct IORequest*)serialData->SerReq);
  166.   Wait(1L << serialData->SerReq->IOSer.io_Message.mn_ReplyPort->mp_SigBit);
  167. */
  168.  
  169.   error = DoIO((struct IORequest*)serialData->SerReq);
  170.   SetSignal(0L, SerialSignal(serialData));
  171.  
  172.   *actual = ((long)serialData->SerReq->IOSer.io_Actual);
  173.   return error;
  174. }
  175.  
  176. /* PROMISE: writes to serial port */
  177. long WriteSer(struct SerialData* serialData, char* data, long length)
  178. {
  179.   long error;
  180.  
  181.   serialData->SerReq->IOSer.io_Data = (APTR)data;
  182.   serialData->SerReq->IOSer.io_Length = length;
  183.   serialData->SerReq->IOSer.io_Command = CMD_WRITE;
  184.   
  185.   error =  DoIO((struct IORequest*)serialData->SerReq);
  186.   SetSignal(0L, SerialSignal(serialData));
  187.   return error;
  188. }
  189.  
  190. /* PROMISE: start serial port */
  191. void StartSer(struct SerialData* serialData) {
  192.  
  193.   serialData->SerReq->IOSer.io_Command = CMD_START;
  194.   DoIO((struct IORequest*)serialData->SerReq);
  195. }
  196.  
  197. void StopSer(struct SerialData* serialData) {
  198.   serialData->SerReq->IOSer.io_Command = CMD_STOP;
  199.   DoIO((struct IORequest*)serialData->SerReq);
  200. }
  201.  
  202. /* ASYNCH stuff */
  203.  
  204. /* PROMISE:  sends an IO request to read from the serial port */
  205. void RecvSer(struct SerialData* serialData, char* data, long length)
  206. {
  207.   serialData->SerReq->IOSer.io_Data = (APTR)data;
  208.   serialData->SerReq->IOSer.io_Length = (ULONG)length;
  209.   serialData->SerReq->IOSer.io_Command = CMD_READ;
  210.   
  211.   SendIO((struct IORequest*)serialData->SerReq);
  212. }
  213.  
  214. /* PROMISE:  sends an IO request to write to the serial port */
  215. void SendSer(struct SerialData* serialData, char* data, long length)
  216. {
  217.   serialData->SerReq->IOSer.io_Data = (APTR)data;
  218.   serialData->SerReq->IOSer.io_Length = length;
  219.   serialData->SerReq->IOSer.io_Command = CMD_WRITE;
  220.   
  221.   SendIO((struct IORequest*)serialData->SerReq);
  222. }
  223.  
  224. ULONG SerialSignal(struct SerialData* serialData) {
  225.   return (ULONG)(1L << serialData->SerReq->IOSer.io_Message.mn_ReplyPort->mp_SigBit);
  226. }
  227.